{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Medical image segmentation with text-based prompts (Inference; Experimental Functionality)\n",
    "\n",
    "In this tutorial, we will show how to use text prompts for medical image segmentation. Algothgh SAM has not released the text-based segmentation, we can implement this function by ourselves since there are many pre-trained text encoders in the community. \n",
    "We used the [MICCAI FLARE 2022](https://zenodo.org/record/7860267) dataset as an example. This is an abdominal organ segmentation task and there are 13 different organs as shown in the following figure. \n",
    "\n",
    "![FLARE22](https://rumc-gcorg-p-public.s3.amazonaws.com/i/2022/03/29/20220309-FLARE22-Pictures-2.png)\n",
    "\n",
    "Assume that you have trained the model following the [training pipeline](https://github.com/bowang-lab/MedSAM/tree/main/extensions/text_prompt). If not, you can use this [checkpoint](https://drive.google.com/file/d/12YH-N6PAKayulhS99MBURVNpuQtVj98S/view?usp=sharing). \n",
    "\n",
    "Note: please install this package: `pip install transformers`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#!pip install git+https://github.com/bowang-lab/MedSAM.git\n",
    "#!pip install transformers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib widget\n",
    "from segment_anything import sam_model_registry\n",
    "from ipywidgets import interact, widgets, FileUpload\n",
    "from segment_anything.modeling import PromptEncoder\n",
    "from transformers import CLIPTextModel\n",
    "from typing import Any, Optional, Tuple, Type\n",
    "from matplotlib import pyplot as plt\n",
    "from copy import deepcopy\n",
    "from torch import nn\n",
    "from torch.nn import functional as F\n",
    "import torch\n",
    "import os\n",
    "join = os.path.join\n",
    "import cv2\n",
    "import numpy as np\n",
    "import SimpleITK as sitk\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Define text prompt encoder\n",
    "\n",
    "We used the pre-trained CLIP model as the text encoder. The prompt encoder in SAM maps all kinds of prompts to the same dimension (256) but the output dimension of CLIP model is 512. Thus, we added an additional projection layer `self.text_encoder_head = nn.Linear(512, embed_dim)` to the text encoder to align the dimension. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class TextPromptEncoder(PromptEncoder):\n",
    "    def __init__(\n",
    "        self,\n",
    "        embed_dim: int,\n",
    "        image_embedding_size: Tuple[int, int],\n",
    "        input_image_size: Tuple[int, int],\n",
    "        mask_in_chans: int = 1,\n",
    "        activation = nn.GELU,\n",
    "        ) -> None:\n",
    "        super().__init__(embed_dim, image_embedding_size, input_image_size, mask_in_chans, activation)\n",
    "        text_encoder = CLIPTextModel.from_pretrained(\"openai/clip-vit-base-patch16\")\n",
    "        text_encoder.requires_grad_(False)\n",
    "        self.text_encoder = text_encoder\n",
    "        self.text_encoder_head = nn.Linear(512, embed_dim)\n",
    "\n",
    "    def forward(\n",
    "        self,\n",
    "        points: Optional[Tuple[torch.Tensor, torch.Tensor]],\n",
    "        boxes: Optional[torch.Tensor],\n",
    "        masks: Optional[torch.Tensor],\n",
    "        tokens: Optional[torch.Tensor],\n",
    "    ):\n",
    "        \"\"\"\n",
    "        Embeds different types of prompts, returning both sparse and dense\n",
    "        embeddings.\n",
    "\n",
    "        Arguments:\n",
    "          points (tuple(torch.Tensor, torch.Tensor) or none): point coordinates\n",
    "            and labels to embed.\n",
    "          boxes (torch.Tensor or none): boxes to embed\n",
    "          masks (torch.Tensor or none): masks to embed\n",
    "\n",
    "        Returns:\n",
    "          torch.Tensor: sparse embeddings for the points and boxes, with shape\n",
    "            BxNx(embed_dim), where N is determined by the number of input points\n",
    "            and boxes.\n",
    "          torch.Tensor: dense embeddings for the masks, in the shape\n",
    "            Bx(embed_dim)x(embed_H)x(embed_W)\n",
    "        \"\"\"\n",
    "        bs = self._get_batch_size(points, boxes, masks, tokens)\n",
    "        sparse_embeddings = torch.empty(\n",
    "            (bs, 0, self.embed_dim), device=self._get_device()\n",
    "        )\n",
    "        if points is not None:\n",
    "            coords, labels = points\n",
    "            point_embeddings = self._embed_points(coords, labels, pad=(boxes is None))\n",
    "            sparse_embeddings = torch.cat([sparse_embeddings, point_embeddings], dim=1)\n",
    "        if boxes is not None:\n",
    "            box_embeddings = self._embed_boxes(boxes)\n",
    "            sparse_embeddings = torch.cat([sparse_embeddings, box_embeddings], dim=1)\n",
    "        if tokens is not None:\n",
    "            encoder_hidden_states = self.text_encoder(tokens)[0]\n",
    "            text_embeddings = self.text_encoder_head(encoder_hidden_states)\n",
    "            sparse_embeddings = torch.cat([sparse_embeddings, text_embeddings], dim=1)\n",
    "\n",
    "        if masks is not None:\n",
    "            dense_embeddings = self._embed_masks(masks)\n",
    "        else:\n",
    "            dense_embeddings = self.no_mask_embed.weight.reshape(1, -1, 1, 1).expand(\n",
    "                bs, -1, self.image_embedding_size[0], self.image_embedding_size[1]\n",
    "            )\n",
    "\n",
    "        return sparse_embeddings, dense_embeddings\n",
    "    \n",
    "    def _get_batch_size(self, points, boxes, masks, tokens):\n",
    "        \"\"\"\n",
    "        Returns the batch size of the inputs.\n",
    "        \"\"\"\n",
    "        if points is not None:\n",
    "            return points[0].shape[0]\n",
    "        elif boxes is not None:\n",
    "            return boxes.shape[0]\n",
    "        elif masks is not None:\n",
    "            return masks.shape[0]\n",
    "        elif tokens is not None:\n",
    "            return tokens.shape[0]\n",
    "        else:\n",
    "            return 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Define the whole model\n",
    "\n",
    "The whole model architecture is the same as the bounding box-based version. The only difference is that the prompt encoder was changed to text encoder.\n",
    "Since MedSAM already provided an image encoder trained on a large scale medical image datasets, we can freeze it and only fine-tune the mask decoder during training. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MedSAMText(nn.Module):\n",
    "    def __init__(self, \n",
    "                image_encoder, \n",
    "                mask_decoder,\n",
    "                prompt_encoder,\n",
    "                device,\n",
    "                ):\n",
    "        super().__init__()\n",
    "        self.image_encoder = image_encoder\n",
    "        self.mask_decoder = mask_decoder\n",
    "        self.prompt_encoder = prompt_encoder\n",
    "        self.device = device\n",
    "\n",
    "    def forward(self, image, tokens):\n",
    "        image_embedding = self.image_encoder(image) # (B, 256, 64, 64)\n",
    "        sparse_embeddings, dense_embeddings = self.prompt_encoder(\n",
    "            points=None,\n",
    "            boxes=None,\n",
    "            masks=None,\n",
    "            tokens=tokens\n",
    "        )\n",
    "        low_res_logits, _ = self.mask_decoder(\n",
    "            image_embeddings=image_embedding, # (B, 256, 64, 64)\n",
    "            image_pe=self.prompt_encoder.get_dense_pe(), # (1, 256, 64, 64)\n",
    "            sparse_prompt_embeddings=sparse_embeddings, # (B, 2, 256)\n",
    "            dense_prompt_embeddings=dense_embeddings, # (B, 256, 64, 64)\n",
    "            multimask_output=False,\n",
    "          ) # (B, 1, 256, 256)\n",
    "\n",
    "        return low_res_logits"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load pre-trained model\n",
    "\n",
    "Two models should be loaded:\n",
    "- the pre-trained MedSAM model\n",
    "- The text encoder and fine-tuned mask decoder"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "MedSAMText(\n",
       "  (image_encoder): ImageEncoderViT(\n",
       "    (patch_embed): PatchEmbed(\n",
       "      (proj): Conv2d(3, 768, kernel_size=(16, 16), stride=(16, 16))\n",
       "    )\n",
       "    (blocks): ModuleList(\n",
       "      (0-11): 12 x Block(\n",
       "        (norm1): LayerNorm((768,), eps=1e-06, elementwise_affine=True)\n",
       "        (attn): Attention(\n",
       "          (qkv): Linear(in_features=768, out_features=2304, bias=True)\n",
       "          (proj): Linear(in_features=768, out_features=768, bias=True)\n",
       "        )\n",
       "        (norm2): LayerNorm((768,), eps=1e-06, elementwise_affine=True)\n",
       "        (mlp): MLPBlock(\n",
       "          (lin1): Linear(in_features=768, out_features=3072, bias=True)\n",
       "          (lin2): Linear(in_features=3072, out_features=768, bias=True)\n",
       "          (act): GELU(approximate='none')\n",
       "        )\n",
       "      )\n",
       "    )\n",
       "    (neck): Sequential(\n",
       "      (0): Conv2d(768, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
       "      (1): LayerNorm2d()\n",
       "      (2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
       "      (3): LayerNorm2d()\n",
       "    )\n",
       "  )\n",
       "  (mask_decoder): MaskDecoder(\n",
       "    (transformer): TwoWayTransformer(\n",
       "      (layers): ModuleList(\n",
       "        (0-1): 2 x TwoWayAttentionBlock(\n",
       "          (self_attn): Attention(\n",
       "            (q_proj): Linear(in_features=256, out_features=256, bias=True)\n",
       "            (k_proj): Linear(in_features=256, out_features=256, bias=True)\n",
       "            (v_proj): Linear(in_features=256, out_features=256, bias=True)\n",
       "            (out_proj): Linear(in_features=256, out_features=256, bias=True)\n",
       "          )\n",
       "          (norm1): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n",
       "          (cross_attn_token_to_image): Attention(\n",
       "            (q_proj): Linear(in_features=256, out_features=128, bias=True)\n",
       "            (k_proj): Linear(in_features=256, out_features=128, bias=True)\n",
       "            (v_proj): Linear(in_features=256, out_features=128, bias=True)\n",
       "            (out_proj): Linear(in_features=128, out_features=256, bias=True)\n",
       "          )\n",
       "          (norm2): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n",
       "          (mlp): MLPBlock(\n",
       "            (lin1): Linear(in_features=256, out_features=2048, bias=True)\n",
       "            (lin2): Linear(in_features=2048, out_features=256, bias=True)\n",
       "            (act): ReLU()\n",
       "          )\n",
       "          (norm3): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n",
       "          (norm4): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n",
       "          (cross_attn_image_to_token): Attention(\n",
       "            (q_proj): Linear(in_features=256, out_features=128, bias=True)\n",
       "            (k_proj): Linear(in_features=256, out_features=128, bias=True)\n",
       "            (v_proj): Linear(in_features=256, out_features=128, bias=True)\n",
       "            (out_proj): Linear(in_features=128, out_features=256, bias=True)\n",
       "          )\n",
       "        )\n",
       "      )\n",
       "      (final_attn_token_to_image): Attention(\n",
       "        (q_proj): Linear(in_features=256, out_features=128, bias=True)\n",
       "        (k_proj): Linear(in_features=256, out_features=128, bias=True)\n",
       "        (v_proj): Linear(in_features=256, out_features=128, bias=True)\n",
       "        (out_proj): Linear(in_features=128, out_features=256, bias=True)\n",
       "      )\n",
       "      (norm_final_attn): LayerNorm((256,), eps=1e-05, elementwise_affine=True)\n",
       "    )\n",
       "    (iou_token): Embedding(1, 256)\n",
       "    (mask_tokens): Embedding(4, 256)\n",
       "    (output_upscaling): Sequential(\n",
       "      (0): ConvTranspose2d(256, 64, kernel_size=(2, 2), stride=(2, 2))\n",
       "      (1): LayerNorm2d()\n",
       "      (2): GELU(approximate='none')\n",
       "      (3): ConvTranspose2d(64, 32, kernel_size=(2, 2), stride=(2, 2))\n",
       "      (4): GELU(approximate='none')\n",
       "    )\n",
       "    (output_hypernetworks_mlps): ModuleList(\n",
       "      (0-3): 4 x MLP(\n",
       "        (layers): ModuleList(\n",
       "          (0-1): 2 x Linear(in_features=256, out_features=256, bias=True)\n",
       "          (2): Linear(in_features=256, out_features=32, bias=True)\n",
       "        )\n",
       "      )\n",
       "    )\n",
       "    (iou_prediction_head): MLP(\n",
       "      (layers): ModuleList(\n",
       "        (0-1): 2 x Linear(in_features=256, out_features=256, bias=True)\n",
       "        (2): Linear(in_features=256, out_features=4, bias=True)\n",
       "      )\n",
       "    )\n",
       "  )\n",
       "  (prompt_encoder): TextPromptEncoder(\n",
       "    (pe_layer): PositionEmbeddingRandom()\n",
       "    (point_embeddings): ModuleList(\n",
       "      (0-3): 4 x Embedding(1, 256)\n",
       "    )\n",
       "    (not_a_point_embed): Embedding(1, 256)\n",
       "    (mask_downscaling): Sequential(\n",
       "      (0): Conv2d(1, 0, kernel_size=(2, 2), stride=(2, 2))\n",
       "      (1): LayerNorm2d()\n",
       "      (2): GELU(approximate='none')\n",
       "      (3): Conv2d(0, 1, kernel_size=(2, 2), stride=(2, 2))\n",
       "      (4): LayerNorm2d()\n",
       "      (5): GELU(approximate='none')\n",
       "      (6): Conv2d(1, 256, kernel_size=(1, 1), stride=(1, 1))\n",
       "    )\n",
       "    (no_mask_embed): Embedding(1, 256)\n",
       "    (text_encoder): CLIPTextModel(\n",
       "      (text_model): CLIPTextTransformer(\n",
       "        (embeddings): CLIPTextEmbeddings(\n",
       "          (token_embedding): Embedding(49408, 512)\n",
       "          (position_embedding): Embedding(77, 512)\n",
       "        )\n",
       "        (encoder): CLIPEncoder(\n",
       "          (layers): ModuleList(\n",
       "            (0-11): 12 x CLIPEncoderLayer(\n",
       "              (self_attn): CLIPAttention(\n",
       "                (k_proj): Linear(in_features=512, out_features=512, bias=True)\n",
       "                (v_proj): Linear(in_features=512, out_features=512, bias=True)\n",
       "                (q_proj): Linear(in_features=512, out_features=512, bias=True)\n",
       "                (out_proj): Linear(in_features=512, out_features=512, bias=True)\n",
       "              )\n",
       "              (layer_norm1): LayerNorm((512,), eps=1e-05, elementwise_affine=True)\n",
       "              (mlp): CLIPMLP(\n",
       "                (activation_fn): QuickGELUActivation()\n",
       "                (fc1): Linear(in_features=512, out_features=2048, bias=True)\n",
       "                (fc2): Linear(in_features=2048, out_features=512, bias=True)\n",
       "              )\n",
       "              (layer_norm2): LayerNorm((512,), eps=1e-05, elementwise_affine=True)\n",
       "            )\n",
       "          )\n",
       "        )\n",
       "        (final_layer_norm): LayerNorm((512,), eps=1e-05, elementwise_affine=True)\n",
       "      )\n",
       "    )\n",
       "    (text_encoder_head): Linear(in_features=512, out_features=256, bias=True)\n",
       "  )\n",
       ")"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "medsam_ckpt_path = \"medsam_vit_b.pth\"\n",
    "device = \"cuda:0\"\n",
    "medsam_model = sam_model_registry['vit_b'](checkpoint=medsam_ckpt_path)\n",
    "medsam_text_demo_checkpoint = \"medsam_text_prompt_flare22.pth\"\n",
    "text_prompt_encoder = TextPromptEncoder(\n",
    "    embed_dim = 256,\n",
    "    image_embedding_size = (64, 64),\n",
    "    input_image_size = (1024, 1024),\n",
    "    mask_in_chans = 1\n",
    ")\n",
    "medsam_text_demo = MedSAMText(\n",
    "    image_encoder=deepcopy(medsam_model.image_encoder),\n",
    "    mask_decoder=deepcopy(medsam_model.mask_decoder),\n",
    "    prompt_encoder=text_prompt_encoder,\n",
    "    device = device\n",
    ")\n",
    "medsam_text_demo_weights = torch.load(medsam_text_demo_checkpoint)\n",
    "for key in medsam_text_demo.state_dict().keys():\n",
    "    if not key.startswith('prompt_encoder.text_encoder.'):\n",
    "        medsam_text_demo.state_dict()[key].copy_(medsam_text_demo_weights[key])\n",
    "medsam_text_demo = medsam_text_demo.to(device)\n",
    "medsam_text_demo.eval()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is a GUI for testing the text-based segmentation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "class TextPromptDemo:\n",
    "    def __init__(self, model):\n",
    "        ## Requires transformers only if users would like to try text prompt\n",
    "        from transformers import CLIPTokenizer\n",
    "        self.tokenizer = CLIPTokenizer.from_pretrained(\"openai/clip-vit-base-patch16\")   \n",
    "        self.model = model\n",
    "        self.model.eval()\n",
    "        self.image = None\n",
    "        self.image_embeddings = None\n",
    "        self.img_size = None\n",
    "        self.img_name = None\n",
    "        self.gt = None\n",
    "        self.label_dict = {\n",
    "            1: [\"liver\"],\n",
    "            2: [\"right kidney\"],\n",
    "            3: [\"spleen\"],\n",
    "            4: [\"pancreas\"],\n",
    "            5: [\"aorta\"],\n",
    "            6: [\"inferior vena cava\", \"ivc\"],\n",
    "            7: [\"right adrenal gland\", \"rag\"],\n",
    "            8: [\"left adrenal gland\", \"lag\"],\n",
    "            9: [\"gallbladder\"],\n",
    "            10: [\"esophagus\"],\n",
    "            11: [\"stomach\"],\n",
    "            12: [\"duodenum\"],\n",
    "            13: [\"left kidney\"]\n",
    "        }\n",
    "        self.caption_label_dict = {}\n",
    "        for label_id, label_list in self.label_dict.items():\n",
    "            for label in label_list:\n",
    "                self.caption_label_dict[label] = label_id\n",
    "\n",
    "        avail_prompts = []\n",
    "        for v in self.label_dict.values():\n",
    "            avail_prompts += v\n",
    "        self.avail_prompts = \", \".join(avail_prompts)\n",
    "\n",
    "    def show_mask(self, mask, ax, random_color=False, alpha=0.95):\n",
    "        if random_color:\n",
    "            color = np.concatenate([np.random.random(3), np.array([alpha])], axis=0)\n",
    "        else:\n",
    "            color = np.array([251/255, 252/255, 30/255, alpha])\n",
    "        h, w = mask.shape[-2:]\n",
    "        mask_image = mask.reshape(h, w, 1) * color.reshape(1, 1, -1)\n",
    "        ax.imshow(mask_image)\n",
    "    \n",
    "    @torch.no_grad()\n",
    "    def infer(self, text):\n",
    "        tokens = self.tokenize_text(text).to(self.model.device)\n",
    "        sparse_embeddings, dense_embeddings = self.model.prompt_encoder(\n",
    "            points = None,\n",
    "            boxes = None,\n",
    "            masks = None,\n",
    "            tokens = tokens\n",
    "        )\n",
    "        low_res_logits, _ = self.model.mask_decoder(\n",
    "            image_embeddings=self.image_embeddings, # (B, 256, 64, 64)\n",
    "            image_pe=self.model.prompt_encoder.get_dense_pe(), # (1, 256, 64, 64)\n",
    "            sparse_prompt_embeddings=sparse_embeddings, # (B, 2, 256)\n",
    "            dense_prompt_embeddings=dense_embeddings, # (B, 256, 64, 64)\n",
    "            multimask_output=False,\n",
    "            )\n",
    "        low_res_pred = torch.sigmoid(low_res_logits)  # (1, 1, 256, 256)\n",
    "        low_res_pred = F.interpolate(\n",
    "            low_res_pred,\n",
    "            size = self.img_size,\n",
    "            mode = 'bilinear',\n",
    "            align_corners = False\n",
    "        )\n",
    "        low_res_pred = low_res_pred.detach().cpu().numpy().squeeze()\n",
    "        seg = np.uint8(low_res_pred > 0.5)\n",
    "\n",
    "        return seg\n",
    "\n",
    "    def show(self, fig_size=3, alpha=0.95):\n",
    "        assert self.image is not None, \"Please set image first.\"\n",
    "        fig, ax = plt.subplots(1, 1, figsize=(fig_size, fig_size))\n",
    "        fig.canvas.header_visible = False\n",
    "        fig.canvas.footer_visible = False\n",
    "        fig.canvas.toolbar_visible = False\n",
    "        fig.canvas.resizable = False\n",
    "\n",
    "        #avil_ids = np.unique(self.gt)[1:]\n",
    "        print(\"Possible prompts:\", self.avail_prompts)\n",
    "\n",
    "        plt.tight_layout()\n",
    "\n",
    "        ax.imshow(np.rot90(self.image, 2), cmap='gray')\n",
    "        ax.axis('off')\n",
    "\n",
    "        text = widgets.Text(\n",
    "            value = '',\n",
    "            placeholder = 'Prompt',\n",
    "            description = 'Enter a prompt',\n",
    "            disabled = False,\n",
    "            style = {'description_width': 'initial'}\n",
    "        )\n",
    "        display(text)\n",
    "\n",
    "        def callback(wget):\n",
    "            caption = wget.value.lower().strip()\n",
    "            if len(fig.texts) > 0:\n",
    "                fig.texts[0].remove()\n",
    "            if caption not in self.avail_prompts:\n",
    "                fig.text(\n",
    "                    0.50,\n",
    "                    0.02,\n",
    "                    f\"Invalid prompt: {wget.value}\",\n",
    "                    horizontalalignment='center',\n",
    "                    wrap=True,\n",
    "                    color='r'\n",
    "                )\n",
    "            else:\n",
    "                ax.clear()\n",
    "                ax.imshow(np.rot90(self.image, 2), cmap='gray')\n",
    "                ax.axis('off')\n",
    "                seg = self.infer(caption)\n",
    "                self.show_mask(np.rot90(seg, 2), ax, random_color=False, alpha=alpha)\n",
    "\n",
    "        text.on_submit(callback)\n",
    "\n",
    "    def set_image(self, image):\n",
    "        self.image = image\n",
    "        self.img_size = image.shape[:2]\n",
    "        if len(image.shape) == 2:\n",
    "            image = np.repeat(image[:,:,None], 3, -1)\n",
    "        image_preprocess = self.preprocess_image(image)\n",
    "        with torch.no_grad():\n",
    "            self.image_embeddings = self.model.image_encoder(image_preprocess)\n",
    "        \n",
    "    def preprocess_image(self, image):\n",
    "        img_resize = cv2.resize(\n",
    "            image,\n",
    "            (1024, 1024),\n",
    "            interpolation=cv2.INTER_CUBIC\n",
    "        )\n",
    "        # Resizing\n",
    "        img_resize = (img_resize - img_resize.min()) / np.clip(img_resize.max() - img_resize.min(), a_min=1e-8, a_max=None) # normalize to [0, 1], (H, W, 3\n",
    "        # convert the shape to (3, H, W)\n",
    "        assert np.max(img_resize)<=1.0 and np.min(img_resize)>=0.0, 'image should be normalized to [0, 1]'\n",
    "        img_tensor = torch.tensor(img_resize).float().permute(2, 0, 1).unsqueeze(0).to(self.model.device)\n",
    "\n",
    "        return img_tensor\n",
    "    \n",
    "\n",
    "    def tokenize_text(self, text):\n",
    "        \"\"\"\n",
    "        Tokenize text using CLIP tokenizer\n",
    "        \"\"\"\n",
    "        return self.tokenizer(\n",
    "            text, max_length=self.tokenizer.model_max_length, padding=\"max_length\", truncation=True, return_tensors=\"pt\" \n",
    "        ).input_ids.squeeze(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load data and run inference"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "3a23a2533b9c429e989604e848f19b41",
       "version_major": 2,
       "version_minor": 0
      },
      "image/png": "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",
      "text/html": [
       "\n",
       "            <div style=\"display: inline-block;\">\n",
       "                <div class=\"jupyter-widgets widget-label\" style=\"text-align: center;\">\n",
       "                    Figure\n",
       "                </div>\n",
       "                <img src='' width=640.0/>\n",
       "            </div>\n",
       "        "
      ],
      "text/plain": [
       "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'middle slice:46')"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# load demo nii data\n",
    "demo_file_nii = \"../../data/FLARE22Train/images/FLARE22_Tr_0046_0000.nii.gz\"\n",
    "file_sitk = sitk.ReadImage(demo_file_nii)\n",
    "image_data = sitk.GetArrayFromImage(file_sitk)\n",
    "# adjust window width and level\n",
    "lower_bound = -240.0\n",
    "upper_bound = 160.0\n",
    "image_data_pre = np.clip(image_data, lower_bound, upper_bound)\n",
    "# normalize to [0, 255]\n",
    "image_data_pre = (image_data_pre - np.min(image_data_pre))/(np.max(image_data_pre)-np.min(image_data_pre))*255.0\n",
    "image_data_pre = np.uint8(image_data_pre)\n",
    "# select middle slice; you can also manually select the slice that you want to test\n",
    "image_slice_id = int(image_data_pre.shape[0]/2)\n",
    "image_slice = image_data_pre[image_slice_id]\n",
    "# show the image to check whether it contains abdominal organs\n",
    "plt.imshow(np.rot90(image_slice, 2), cmap='gray')\n",
    "plt.show()\n",
    "plt.title('middle slice:'+str(image_slice_id))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "input prompt in the following prompt box, e.g., liver and press `Enter`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Possible prompts: liver, right kidney, spleen, pancreas, aorta, inferior vena cava, ivc, right adrenal gland, rag, left adrenal gland, lag, gallbladder, esophagus, stomach, duodenum, left kidney\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "6a1ab2570f714d3289cfe073fe972302",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "Text(value='', description='Enter a prompt', placeholder='Prompt', style=TextStyle(description_width='initial'…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "380e065e0491416ca92e72b2de6a734a",
       "version_major": 2,
       "version_minor": 0
      },
      "image/png": "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",
      "text/html": [
       "\n",
       "            <div style=\"display: inline-block;\">\n",
       "                <div class=\"jupyter-widgets widget-label\" style=\"text-align: center;\">\n",
       "                    Figure\n",
       "                </div>\n",
       "                <img src='' width=300.0/>\n",
       "            </div>\n",
       "        "
      ],
      "text/plain": [
       "Canvas(footer_visible=False, header_visible=False, resizable=False, toolbar=Toolbar(toolitems=[('Home', 'Reset…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "text_prompt_demo = TextPromptDemo(medsam_text_demo)\n",
    "text_prompt_demo.set_image(image_slice)\n",
    "text_prompt_demo.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Closing remarks\n",
    "\n",
    "This is still an experimental function at present. There is a large room for further improvements, such as open-vocabulary segmentation. Compared to other prompts, text-prompt provided a straightforward way to integrate partially labeled datasets since it eliminates the limation of fully labeled datasets in typical semantic segmentation tasks! We're excited about this research direction. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
